home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / fp / ifp_unix.lzh / ifp / interp / inob.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-23  |  6.4 KB  |  273 lines
  1.  
  2. /****** inob.c ********************************************************/
  3. /**                                                                  **/
  4. /**                    University of Illinois                        **/
  5. /**                                                                  **/
  6. /**                Department of Computer Science                    **/
  7. /**                                                                  **/
  8. /**   Tool: IFP                         Version: 0.5                 **/
  9. /**                                                                  **/
  10. /**   Author:  Arch D. Robison          Date:   May 1, 1985          **/
  11. /**                                                                  **/
  12. /**   Revised by: Arch D. Robison       Date:   Aug 6, 1986          **/
  13. /**                                                                  **/
  14. /**   Principal Investigators: Prof. R. H. Campbell                  **/
  15. /**                            Prof. W. J. Kubitz                    **/
  16. /**                                                                  **/
  17. /**                                                                  **/
  18. /**------------------------------------------------------------------**/
  19. /**   (C) Copyright 1987  University of Illinois Board of Trustees   **/
  20. /**                       All Rights Reserved.                       **/
  21. /**********************************************************************/
  22.  
  23. /*************** object input parser (recursive descent) ***************/
  24.  
  25.  
  26. #include <stdio.h>
  27. #include <ctype.h>
  28. #include "struct.h"
  29. #include "node.h"
  30. #include "string.h"
  31. #include "inob.h"
  32.  
  33. /*
  34.  * ObDelim
  35.  *
  36.  * Theses characters delimit objects.
  37.  * Compare with NodeDelim in inimport.c 
  38.  */
  39. private char ObDelim[] = " ,<>|[](){};:\t\n";
  40.  
  41. /*
  42.  * InBlanks
  43.  *
  44.  * Skip to first non-blank character not in comment.
  45.  *
  46.  * Input
  47.  *     F = input descriptor
  48.  *
  49.  * Output
  50.  *    F = input descriptor pointing to non-blank character
  51.  */
  52. void InBlanks (F)
  53.    register InDesc *F;
  54.    {
  55.       while (1) {
  56.  
  57.      while (1) {
  58.         if (!*F->InPtr)
  59.            if (F->InLineNum >= 0) 
  60.           if (NULL != fgets (F->InBuf,INBUFSIZE,F->InFile)) {
  61.              F->InPtr = F->InBuf;
  62.              F->InLineNum++;
  63.           }
  64.         if (!isspace (*F->InPtr)) break;
  65.         F->InPtr++;
  66.      }
  67.  
  68.      if (*F->InPtr == '(' && F->InPtr[1] == '*') {
  69.         F->ComLevel++;
  70.         F->InPtr+=2;
  71.      } else if (*F->InPtr == '*' && F->InPtr[1] == ')') {
  72.         F->ComLevel--;
  73.         F->InPtr+=2;
  74.      } else if (F->ComLevel && *F->InPtr) F->InPtr++;
  75.      else break;
  76.       }
  77.    }
  78.  
  79. /*
  80.  * IsTok
  81.  *
  82.  * Check if next token in input stream F is token S.  
  83.  * If found, then skip to next token.
  84.  */
  85. boolean IsTok (F,S)
  86.    InDesc *F;
  87.    register char *S;
  88.    {
  89.       register char *T;
  90.  
  91.       for (T = F->InPtr; *S; S++,T++)
  92.      if (*S != *T) return 0;
  93.  
  94.       /* Check if alphabetic token is prefix of longer token */
  95.       if (isalpha (T[-1]) && isalpha (T[0])) return 0; 
  96.  
  97.       F->InPtr = T;
  98.       InBlanks (F);
  99.       return 1;
  100.    }
  101.  
  102. /*
  103.  * InString
  104.  *
  105.  * Input a string. 
  106.  *
  107.  * Input
  108.  *      *F = input descriptor pointing to first character of string
  109.  *      Delim = string of non-alphanumeric delimiters
  110.  *      Quoted = skip closing delimiter
  111.  *
  112.  * Output
  113.  *      *F = input descriptor pointing to next token after string
  114.  *      X = string object
  115.  *      result = pointer to string, NULL if SysError or empty string.
  116.  *
  117.  * A SysError may occur, in which case X = bottom.
  118.  */
  119. StrPtr InString (F,X,Delim,Quoted)
  120.    register InDesc *F;
  121.    ObjectPtr X;
  122.    char *Delim;
  123.    boolean Quoted;
  124.    {
  125.       CharPtr U;
  126.       register char C;
  127.  
  128.       RepTag (X,STRING);
  129.       X->String = NULL;
  130.       CPInit (&U,&X->String);
  131.       do {
  132.          extern char *index ();
  133.      C = *F->InPtr++;
  134.      if (!isalnum (C) && NULL != index (Delim,C)) C = '\0';
  135.      CPAppend (&U,C);
  136.      if (SysError) {RepTag (X,BOTTOM); return NULL;}
  137.       } while (C);
  138.       if (!Quoted) F->InPtr--;
  139.       InBlanks (F);
  140.       return X->String;
  141.    }
  142.  
  143.  
  144. /*
  145.  * InList
  146.  *
  147.  * Input a list
  148.  *
  149.  * Input
  150.  *     F = input descriptor pointing to first token after '<'
  151.  *
  152.  * Output
  153.  *     result = true iff no error occurs
  154.  *     *X = sequence, or unchanged if error occurs.
  155.  */
  156. private boolean InList (F,X)
  157.    register InDesc *F;
  158.    ObjectPtr X;
  159.    {
  160.       ListPtr R=NULL;
  161.       register MetaPtr A = &R;
  162.  
  163.       while (!IsTok (F,">")) {
  164.      if (EndOfFile (F)) {
  165.         DelLPtr (R);
  166.         return InError (F,"unfinished sequence");
  167.      }   
  168.      NewList (A,1L);
  169.      if (SysError || !InObject (F,&(*A)->Val)) {
  170.         DelLPtr (R);
  171.         return 0;
  172.      }
  173.      A = & (*A)->Next;
  174.      (void) IsTok (F,",");
  175.       }
  176.       RepTag (X,LIST);
  177.       X->List = R;
  178.       return 1;
  179.    }
  180.  
  181. /*
  182.  * InObject
  183.  *
  184.  * Read an object.
  185.  *
  186.  * Input
  187.  *      *F = input descriptor pointing to object
  188.  *
  189.  * Output
  190.  *      *F = input descriptor pointing to next token
  191.  *    result = true iff object is read successfully.
  192.  *
  193.  * A SysError may occur, in which case X is unchanged.
  194.  */
  195. boolean InObject (F,X)
  196.    register InDesc *F;
  197.    register ObjectPtr X;
  198.    {
  199.       if (IsTok (F,"<")) return InList (F,X);
  200.  
  201.       else if (IsTok (F,"(")) {
  202.  
  203.      (void) InComp (F,X,NIL);
  204.      if (!IsTok (F,")")) return InError (F,"')' expected");
  205.  
  206.       } else { 
  207.  
  208.      /* Input atom */
  209.  
  210.      static char Delim[2] = {'\0','\0'};
  211.      *Delim = *F->InPtr;
  212.  
  213.      if (*Delim == '\"' || *Delim == '\'') {
  214.         F->InPtr++;
  215.         (void) InString (F,X,Delim,1);
  216.      } else {
  217.  
  218.         FPint K;
  219.         register StrPtr S = InString (F,X,ObDelim,0);
  220.         if (S == NULL) return SysError || InError (F,"object expected");
  221.         if (S->StrChar[1] == '\0')
  222.            switch (S->StrChar[0]) {
  223.           case 'f':
  224.              RepBool (X,0);
  225.              return 1;
  226.           case 't':
  227.              RepBool (X,1);
  228.              return 1;
  229.           case '?':
  230.              RepTag (X,BOTTOM);
  231.              return 1;
  232.            }
  233.         if (StrToFloat (X) && !GetFPInt (X,&K)) {
  234.            X->Tag = INT;
  235.            X->Int = K;
  236.         } 
  237.      }
  238.       }
  239.       return 1;
  240.    }
  241.  
  242. /*
  243.  * InitIn
  244.  *
  245.  * Initialize input descriptor for node N and file FileDesc.
  246.  * Advance the input pointer to the first token.
  247.  *
  248.  * Input
  249.  *    *F = input descriptor
  250.  *    M = module pointer (IFP only)
  251.  *    ClassName = class name (OOFP only)
  252.  *    FileDesc = open file descriptor
  253.  *    LineNum = 0 for normal input, -1 if single-line mode
  254.  */
  255. void InitIn (F,M,FileDesc,LineNum)
  256.    NodePtr M;
  257.    register InDesc *F;
  258.    FILE *FileDesc;
  259.    int LineNum;
  260.    {
  261.       F->InFile = FileDesc;
  262.       F->InLineNum= LineNum;
  263.       F->InPtr = F->InBuf;
  264.       *F->InPtr = '\0';
  265.       F->InDefMod = M;
  266.       F->ComLevel = 0;
  267.       InBlanks (F);
  268.    }
  269.  
  270.  
  271. /******************************* end of inob.c *******************************/
  272.  
  273.